package untils

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	"github.com/xuri/excelize/v2"
)

// ExcelExporter Excel导出器
type ExcelExporter struct {
	file     *excelize.File
	fileName string
	filePath string
}

// NewExcelExporter 创建新的Excel导出器
func NewExcelExporter(fileName string) (*ExcelExporter, error) {
	// 确保导出目录存在
	exportDir := "export_files"
	if err := os.MkdirAll(exportDir, 0755); err != nil {
		return nil, fmt.Errorf("创建导出目录失败: %v", err)
	}

	// 生成完整的文件路径
	filePath := filepath.Join(exportDir, fileName+".xlsx")

	// 创建新的Excel文件
	file := excelize.NewFile()

	// 删除默认的Sheet1
	file.DeleteSheet("Sheet1")

	return &ExcelExporter{
		file:     file,
		fileName: fileName,
		filePath: filePath,
	}, nil
}

// CreateSheet 创建工作表
func (e *ExcelExporter) CreateSheet(sheetName string) error {
	_, err := e.file.NewSheet(sheetName)
	return err
}

// SetActiveSheet 设置活动工作表
func (e *ExcelExporter) SetActiveSheet(sheetName string) error {
	index, err := e.file.GetSheetIndex(sheetName)
	if err != nil {
		return err
	}
	e.file.SetActiveSheet(index)
	return nil
}

// WriteHeaders 写入表头
func (e *ExcelExporter) WriteHeaders(sheetName string, headers []string) error {
	for i, header := range headers {
		cell := fmt.Sprintf("%c1", 'A'+i)
		e.file.SetCellValue(sheetName, cell, header)
	}
	return nil
}

// WriteRow 写入数据行
func (e *ExcelExporter) WriteRow(sheetName string, row int, data []interface{}) error {
	for i, value := range data {
		cell := fmt.Sprintf("%c%d", 'A'+i, row)
		e.file.SetCellValue(sheetName, cell, value)
	}
	return nil
}

// WriteRows 批量写入数据行
func (e *ExcelExporter) WriteRows(sheetName string, startRow int, data [][]interface{}) error {
	for i, row := range data {
		if err := e.WriteRow(sheetName, startRow+i, row); err != nil {
			return err
		}
	}
	return nil
}

// SetColumnWidth 设置列宽
func (e *ExcelExporter) SetColumnWidth(sheetName string, col string, width float64) error {
	return e.file.SetColWidth(sheetName, col, col, width)
}

// SetRowHeight 设置行高
func (e *ExcelExporter) SetRowHeight(sheetName string, row int, height float64) error {
	return e.file.SetRowHeight(sheetName, row, height)
}

// AddStyle 添加样式
func (e *ExcelExporter) AddStyle(style *excelize.Style) (int, error) {
	return e.file.NewStyle(style)
}

// ApplyStyle 应用样式
func (e *ExcelExporter) ApplyStyle(sheetName, cellRange string, styleID int) error {
	return e.file.SetCellStyle(sheetName, cellRange, cellRange, styleID)
}

// Save 保存文件
func (e *ExcelExporter) Save() error {
	return e.file.SaveAs(e.filePath)
}

// GetFilePath 获取文件路径
func (e *ExcelExporter) GetFilePath() string {
	return e.filePath
}

// GetFileName 获取文件名
func (e *ExcelExporter) GetFileName() string {
	return e.fileName
}

// Close 关闭文件
func (e *ExcelExporter) Close() error {
	return e.file.Close()
}

// ValidateData 验证数据完整性
func ValidateData(data []FinancialReconciliationData) error {
	if len(data) == 0 {
		return fmt.Errorf("数据为空")
	}

	for i, item := range data {
		if item.OrderId == "" {
			return fmt.Errorf("第%d行订单编号为空", i+1)
		}
		if item.ActualPayment < 0 {
			return fmt.Errorf("第%d行实际支付金额不能为负数", i+1)
		}
		if item.PlatformFee < 0 {
			return fmt.Errorf("第%d行平台费用不能为负数", i+1)
		}
		if item.DriverIncome < 0 {
			return fmt.Errorf("第%d行司机收入不能为负数", i+1)
		}
	}

	return nil
}

// CreateFinancialReconciliationExcelWithValidation 创建财务对账Excel文件（带数据验证）
func CreateFinancialReconciliationExcelWithValidation(taskID string, data []FinancialReconciliationData) (string, error) {
	// 验证数据
	if err := ValidateData(data); err != nil {
		return "", fmt.Errorf("数据验证失败: %v", err)
	}

	// 创建Excel导出器
	exporter, err := NewExcelExporter("financial_reconciliation_" + taskID)
	if err != nil {
		return "", fmt.Errorf("创建Excel导出器失败: %v", err)
	}
	defer exporter.Close()

	// 创建主工作表
	if err := exporter.CreateSheet("财务对账数据"); err != nil {
		return "", fmt.Errorf("创建工作表失败: %v", err)
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("财务对账数据"); err != nil {
		return "", fmt.Errorf("设置活动工作表失败: %v", err)
	}

	// 写入表头
	headers := []string{
		"订单编号", "用户ID", "用户名", "司机ID", "司机姓名", "订单时间",
		"起点位置", "终点位置", "总距离(km)", "实际支付(元)", "平台费用(元)",
		"司机收入(元)", "订单状态", "支付方式", "支付时间", "优惠券折扣(元)",
		"高峰倍数", "备注",
	}

	if err := exporter.WriteHeaders("财务对账数据", headers); err != nil {
		return "", fmt.Errorf("写入表头失败: %v", err)
	}

	// 批量写入数据，带错误处理
	batchSize := 1000
	for i := 0; i < len(data); i += batchSize {
		end := i + batchSize
		if end > len(data) {
			end = len(data)
		}

		batch := data[i:end]
		var batchData [][]interface{}

		for _, item := range batch {
			rowData := []interface{}{
				item.OrderId,
				item.UserId,
				item.Username,
				item.DriverId,
				item.DriverName,
				item.OrderTime,
				item.StartLocation,
				item.EndLocation,
				item.TotalDistance,
				item.ActualPayment,
				item.PlatformFee,
				item.DriverIncome,
				getOrderStatusText(item.OrderStatus),
				getPaymentMethodText(item.PaymentMethod),
				item.PaymentTime,
				item.CouponDiscount,
				item.SurgeMultiplier,
				item.Remark,
			}
			batchData = append(batchData, rowData)
		}

		// 批量写入数据
		if err := exporter.WriteRows("财务对账数据", i+2, batchData); err != nil {
			return "", fmt.Errorf("写入数据行失败: %v", err)
		}
	}

	// 设置列宽
	columnWidths := map[string]float64{
		"A": 20, "B": 10, "C": 15, "D": 10, "E": 15, "F": 20,
		"G": 25, "H": 25, "I": 12, "J": 15, "K": 15, "L": 15,
		"M": 12, "N": 12, "O": 20, "P": 15, "Q": 15, "R": 15,
	}

	for col, width := range columnWidths {
		if err := exporter.SetColumnWidth("财务对账数据", col, width); err != nil {
			log.Printf("设置列宽失败: %v", err)
		}
	}

	// 创建汇总工作表
	if err := createSummarySheet(exporter, data); err != nil {
		log.Printf("创建汇总工作表失败: %v", err)
	}

	// 保存文件
	if err := exporter.Save(); err != nil {
		return "", fmt.Errorf("保存Excel文件失败: %v", err)
	}

	log.Printf("财务对账Excel文件创建成功: %s", exporter.GetFilePath())
	return exporter.GetFilePath(), nil
}

// CreateFinancialReconciliationExcel 创建财务对账Excel文件
func CreateFinancialReconciliationExcel(taskID string, data []FinancialReconciliationData) (string, error) {
	// 创建Excel导出器
	exporter, err := NewExcelExporter("financial_reconciliation_" + taskID)
	if err != nil {
		return "", fmt.Errorf("创建Excel导出器失败: %v", err)
	}
	defer exporter.Close()

	// 创建主工作表
	if err := exporter.CreateSheet("财务对账数据"); err != nil {
		return "", fmt.Errorf("创建工作表失败: %v", err)
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("财务对账数据"); err != nil {
		return "", fmt.Errorf("设置活动工作表失败: %v", err)
	}

	// 写入表头
	headers := []string{
		"订单编号", "用户ID", "用户名", "司机ID", "司机姓名", "订单时间",
		"起点位置", "终点位置", "总距离(km)", "实际支付(元)", "平台费用(元)",
		"司机收入(元)", "订单状态", "支付方式", "支付时间", "优惠券折扣(元)",
		"高峰倍数", "备注",
	}

	if err := exporter.WriteHeaders("财务对账数据", headers); err != nil {
		return "", fmt.Errorf("写入表头失败: %v", err)
	}

	// 批量写入数据，提高性能
	batchSize := 1000
	for i := 0; i < len(data); i += batchSize {
		end := i + batchSize
		if end > len(data) {
			end = len(data)
		}

		batch := data[i:end]
		var batchData [][]interface{}

		for _, item := range batch {
			rowData := []interface{}{
				item.OrderId,
				item.UserId,
				item.Username,
				item.DriverId,
				item.DriverName,
				item.OrderTime,
				item.StartLocation,
				item.EndLocation,
				item.TotalDistance,
				item.ActualPayment,
				item.PlatformFee,
				item.DriverIncome,
				getOrderStatusText(item.OrderStatus),
				getPaymentMethodText(item.PaymentMethod),
				item.PaymentTime,
				item.CouponDiscount,
				item.SurgeMultiplier,
				item.Remark,
			}
			batchData = append(batchData, rowData)
		}

		// 批量写入数据
		if err := exporter.WriteRows("财务对账数据", i+2, batchData); err != nil {
			return "", fmt.Errorf("写入数据行失败: %v", err)
		}
	}

	// 设置列宽
	columnWidths := map[string]float64{
		"A": 20, "B": 10, "C": 15, "D": 10, "E": 15, "F": 20,
		"G": 25, "H": 25, "I": 12, "J": 15, "K": 15, "L": 15,
		"M": 12, "N": 12, "O": 20, "P": 15, "Q": 15, "R": 15,
	}

	for col, width := range columnWidths {
		if err := exporter.SetColumnWidth("财务对账数据", col, width); err != nil {
			log.Printf("设置列宽失败: %v", err)
		}
	}

	// 创建汇总工作表
	if err := createSummarySheet(exporter, data); err != nil {
		log.Printf("创建汇总工作表失败: %v", err)
	}

	// 保存文件
	if err := exporter.Save(); err != nil {
		return "", fmt.Errorf("保存Excel文件失败: %v", err)
	}

	log.Printf("财务对账Excel文件创建成功: %s", exporter.GetFilePath())
	return exporter.GetFilePath(), nil
}

// CreateFinancialReconciliationExcelWithProgress 创建财务对账Excel文件（带进度跟踪）
func CreateFinancialReconciliationExcelWithProgress(taskID string, data []FinancialReconciliationData, progressCallback func(int, int)) (string, error) {
	// 创建Excel导出器
	exporter, err := NewExcelExporter("financial_reconciliation_" + taskID)
	if err != nil {
		return "", fmt.Errorf("创建Excel导出器失败: %v", err)
	}
	defer exporter.Close()

	// 创建主工作表
	if err := exporter.CreateSheet("财务对账数据"); err != nil {
		return "", fmt.Errorf("创建工作表失败: %v", err)
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("财务对账数据"); err != nil {
		return "", fmt.Errorf("设置活动工作表失败: %v", err)
	}

	// 写入表头
	headers := []string{
		"订单编号", "用户ID", "用户名", "司机ID", "司机姓名", "订单时间",
		"起点位置", "终点位置", "总距离(km)", "实际支付(元)", "平台费用(元)",
		"司机收入(元)", "订单状态", "支付方式", "支付时间", "优惠券折扣(元)",
		"高峰倍数", "备注",
	}

	if err := exporter.WriteHeaders("财务对账数据", headers); err != nil {
		return "", fmt.Errorf("写入表头失败: %v", err)
	}

	// 批量写入数据，带进度回调
	batchSize := 1000
	totalRecords := len(data)

	for i := 0; i < totalRecords; i += batchSize {
		end := i + batchSize
		if end > totalRecords {
			end = totalRecords
		}

		batch := data[i:end]
		var batchData [][]interface{}

		for _, item := range batch {
			rowData := []interface{}{
				item.OrderId,
				item.UserId,
				item.Username,
				item.DriverId,
				item.DriverName,
				item.OrderTime,
				item.StartLocation,
				item.EndLocation,
				item.TotalDistance,
				item.ActualPayment,
				item.PlatformFee,
				item.DriverIncome,
				getOrderStatusText(item.OrderStatus),
				getPaymentMethodText(item.PaymentMethod),
				item.PaymentTime,
				item.CouponDiscount,
				item.SurgeMultiplier,
				item.Remark,
			}
			batchData = append(batchData, rowData)
		}

		// 批量写入数据
		if err := exporter.WriteRows("财务对账数据", i+2, batchData); err != nil {
			return "", fmt.Errorf("写入数据行失败: %v", err)
		}

		// 调用进度回调
		if progressCallback != nil {
			progressCallback(end, totalRecords)
		}
	}

	// 设置列宽
	columnWidths := map[string]float64{
		"A": 20, "B": 10, "C": 15, "D": 10, "E": 15, "F": 20,
		"G": 25, "H": 25, "I": 12, "J": 15, "K": 15, "L": 15,
		"M": 12, "N": 12, "O": 20, "P": 15, "Q": 15, "R": 15,
	}

	for col, width := range columnWidths {
		if err := exporter.SetColumnWidth("财务对账数据", col, width); err != nil {
			log.Printf("设置列宽失败: %v", err)
		}
	}

	// 创建汇总工作表
	if err := createSummarySheet(exporter, data); err != nil {
		log.Printf("创建汇总工作表失败: %v", err)
	}

	// 保存文件
	if err := exporter.Save(); err != nil {
		return "", fmt.Errorf("保存Excel文件失败: %v", err)
	}

	log.Printf("财务对账Excel文件创建成功: %s", exporter.GetFilePath())
	return exporter.GetFilePath(), nil
}

// createSummarySheet 创建汇总工作表
func createSummarySheet(exporter *ExcelExporter, data []FinancialReconciliationData) error {
	// 创建汇总工作表
	if err := exporter.CreateSheet("数据汇总"); err != nil {
		return err
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("数据汇总"); err != nil {
		return err
	}

	// 写入汇总表头
	summaryHeaders := []string{"统计项目", "数值", "说明"}
	if err := exporter.WriteHeaders("数据汇总", summaryHeaders); err != nil {
		return err
	}

	// 计算汇总数据
	totalAmount := 0.0
	totalPlatformFee := 0.0
	totalDriverIncome := 0.0
	totalRecords := len(data)

	for _, item := range data {
		totalAmount += item.ActualPayment
		totalPlatformFee += item.PlatformFee
		totalDriverIncome += item.DriverIncome
	}

	// 写入汇总数据
	summaryData := [][]interface{}{
		{"总记录数", totalRecords, "导出的财务对账记录总数"},
		{"总金额(元)", fmt.Sprintf("%.2f", totalAmount), "所有订单的总金额"},
		{"平台总收入(元)", fmt.Sprintf("%.2f", totalPlatformFee), "平台从所有订单中获得的收入"},
		{"司机总收入(元)", fmt.Sprintf("%.2f", totalDriverIncome), "司机从所有订单中获得的收入"},
		{"平均订单金额(元)", fmt.Sprintf("%.2f", totalAmount/float64(totalRecords)), "每个订单的平均金额"},
		{"平台佣金比例", fmt.Sprintf("%.2f%%", (totalPlatformFee/totalAmount)*100), "平台收入占总收入的比例"},
		{"导出时间", time.Now().Format("2006-01-02 15:04:05"), "数据导出的时间"},
	}

	if err := exporter.WriteRows("数据汇总", 2, summaryData); err != nil {
		return err
	}

	// 设置列宽
	exporter.SetColumnWidth("数据汇总", "A", 20)
	exporter.SetColumnWidth("数据汇总", "B", 20)
	exporter.SetColumnWidth("数据汇总", "C", 40)

	return nil
}

// FinancialReconciliationData 财务对账数据结构
type FinancialReconciliationData struct {
	OrderId         string  `json:"order_id"`
	UserId          string  `json:"user_id"`
	Username        string  `json:"username"`
	DriverId        string  `json:"driver_id"`
	DriverName      string  `json:"driver_name"`
	OrderTime       string  `json:"order_time"`
	StartLocation   string  `json:"start_location"`
	EndLocation     string  `json:"end_location"`
	TotalDistance   float64 `json:"total_distance"`
	ActualPayment   float64 `json:"actual_payment"`
	PlatformFee     float64 `json:"platform_fee"`
	DriverIncome    float64 `json:"driver_income"`
	OrderStatus     int32   `json:"order_status"`
	PaymentMethod   int32   `json:"payment_method"`
	PaymentTime     string  `json:"payment_time"`
	CouponDiscount  float64 `json:"coupon_discount"`
	SurgeMultiplier float64 `json:"surge_multiplier"`
	Remark          string  `json:"remark"`
}

// getOrderStatusText 获取订单状态文本
func getOrderStatusText(status int32) string {
	switch status {
	case 1:
		return "待接单"
	case 2:
		return "待上车"
	case 3:
		return "行驶中"
	case 4:
		return "待支付"
	case 5:
		return "已完成"
	case 6:
		return "已取消"
	case 7:
		return "已退款"
	default:
		return "未知"
	}
}

// getPaymentMethodText 获取支付方式文本
func getPaymentMethodText(method int32) string {
	switch method {
	case 1:
		return "支付宝"
	case 2:
		return "微信"
	case 3:
		return "信用卡"
	case 4:
		return "电子钱包"
	case 5:
		return "其他"
	default:
		return "未知"
	}
}

// CreateTransactionDetailExcel 创建交易详情Excel文件
func CreateTransactionDetailExcel(taskID string, data []TransactionDetailData) (string, error) {
	// 创建Excel导出器
	exporter, err := NewExcelExporter("transaction_detail_" + taskID)
	if err != nil {
		return "", fmt.Errorf("创建Excel导出器失败: %v", err)
	}
	defer exporter.Close()

	// 创建主工作表
	if err := exporter.CreateSheet("交易详情"); err != nil {
		return "", fmt.Errorf("创建工作表失败: %v", err)
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("交易详情"); err != nil {
		return "", fmt.Errorf("设置活动工作表失败: %v", err)
	}

	// 写入表头
	headers := []string{
		"交易ID", "订单编号", "交易类型", "金额(元)", "平台收入(元)",
		"司机收入(元)", "支付方式", "交易时间", "用户名", "司机姓名",
		"订单状态", "备注",
	}

	if err := exporter.WriteHeaders("交易详情", headers); err != nil {
		return "", fmt.Errorf("写入表头失败: %v", err)
	}

	// 写入数据
	for i, item := range data {
		row := i + 2 // 从第2行开始写入数据
		rowData := []interface{}{
			item.Id,
			item.OrderSn,
			getTransactionTypeText(item.TransactionType),
			item.Amount,
			item.PlatformRevenue,
			item.DriverRevenue,
			getPaymentMethodText(int32(item.PayWay)),
			item.TransactionTime.Format("2006-01-02 15:04:05"),
			item.UserName,
			item.DriverName,
			getOrderStatusText(int32(item.OrderStatus)),
			item.Remark,
		}

		if err := exporter.WriteRow("交易详情", row, rowData); err != nil {
			return "", fmt.Errorf("写入数据行失败: %v", err)
		}
	}

	// 设置列宽
	columnWidths := map[string]float64{
		"A": 10, "B": 20, "C": 12, "D": 15, "E": 15, "F": 15,
		"G": 12, "H": 20, "I": 15, "J": 15, "K": 12, "L": 30,
	}

	for col, width := range columnWidths {
		if err := exporter.SetColumnWidth("交易详情", col, width); err != nil {
			log.Printf("设置列宽失败: %v", err)
		}
	}

	// 保存文件
	if err := exporter.Save(); err != nil {
		return "", fmt.Errorf("保存Excel文件失败: %v", err)
	}

	log.Printf("交易详情Excel文件创建成功: %s", exporter.GetFilePath())
	return exporter.GetFilePath(), nil
}

// TransactionDetailData 交易详情数据结构
type TransactionDetailData struct {
	Id              uint32    `json:"id"`
	OrderSn         string    `json:"order_sn"`
	TransactionType uint8     `json:"transaction_type"`
	Amount          float64   `json:"amount"`
	PlatformRevenue float64   `json:"platform_revenue"`
	DriverRevenue   float64   `json:"driver_revenue"`
	PayWay          uint8     `json:"pay_way"`
	TransactionTime time.Time `json:"transaction_time"`
	UserName        string    `json:"user_name"`
	DriverName      string    `json:"driver_name"`
	OrderStatus     int8      `json:"order_status"`
	Remark          string    `json:"remark"`
}

// getTransactionTypeText 获取交易类型文本
func getTransactionTypeText(transactionType uint8) string {
	switch transactionType {
	case 1:
		return "收入"
	case 2:
		return "支出"
	default:
		return "未知"
	}
}

// CreateOrderExcel 创建订单Excel文件（优化版）
func CreateOrderExcel(taskID string, data []OrderData) (string, error) {
	return CreateOrderExcelWithProgress(taskID, data, nil)
}

// CreateOrderExcelWithProgress 创建订单Excel文件（带进度跟踪）
func CreateOrderExcelWithProgress(taskID string, data []OrderData, progressCallback func(int, int)) (string, error) {
	// 数据验证
	if err := validateOrderData(data); err != nil {
		return "", fmt.Errorf("数据验证失败: %v", err)
	}

	// 创建Excel导出器
	exporter, err := NewExcelExporter("order_export_" + taskID)
	if err != nil {
		return "", fmt.Errorf("创建Excel导出器失败: %v", err)
	}
	defer exporter.Close()

	// 创建主工作表
	if err := exporter.CreateSheet("订单数据"); err != nil {
		return "", fmt.Errorf("创建工作表失败: %v", err)
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("订单数据"); err != nil {
		return "", fmt.Errorf("设置活动工作表失败: %v", err)
	}

	// 写入表头
	headers := []string{
		"订单编号", "用户ID", "司机ID", "订单类型", "订单金额(元)", "创建时间", "订单状态",
	}

	if err := exporter.WriteHeaders("订单数据", headers); err != nil {
		return "", fmt.Errorf("写入表头失败: %v", err)
	}

	// 批量写入数据，带进度回调
	batchSize := 1000
	totalRecords := len(data)

	for i := 0; i < totalRecords; i += batchSize {
		end := i + batchSize
		if end > totalRecords {
			end = totalRecords
		}

		batch := data[i:end]
		var batchData [][]interface{}

		for _, item := range batch {
			rowData := []interface{}{
				item.OrderSn,
				item.UserId,
				item.DriverId,
				getOrderTypeText(item.OrderType),
				item.Price,
				item.CreateAt.Format("2006-01-02 15:04:05"),
				getOrderStatusText(int32(item.OrderStatus)),
			}
			batchData = append(batchData, rowData)
		}

		// 批量写入数据
		if err := exporter.WriteRows("订单数据", i+2, batchData); err != nil {
			return "", fmt.Errorf("写入数据行失败: %v", err)
		}

		// 调用进度回调
		if progressCallback != nil {
			progressCallback(end, totalRecords)
		}
	}

	// 设置列宽
	columnWidths := map[string]float64{
		"A": 20, "B": 10, "C": 10, "D": 12, "E": 15, "F": 20, "G": 12,
	}

	for col, width := range columnWidths {
		if err := exporter.SetColumnWidth("订单数据", col, width); err != nil {
			log.Printf("设置列宽失败: %v", err)
		}
	}

	// 创建汇总工作表
	if err := createOrderSummarySheet(exporter, data); err != nil {
		log.Printf("创建汇总工作表失败: %v", err)
	}

	// 保存文件
	if err := exporter.Save(); err != nil {
		return "", fmt.Errorf("保存Excel文件失败: %v", err)
	}

	log.Printf("订单Excel文件创建成功: %s", exporter.GetFilePath())
	return exporter.GetFilePath(), nil
}

// 数据验证
func validateOrderData(data []OrderData) error {
	if len(data) == 0 {
		return fmt.Errorf("数据为空")
	}

	for i, item := range data {
		if item.OrderSn == "" {
			return fmt.Errorf("第%d行订单编号为空", i+1)
		}
		if item.UserId == 0 {
			return fmt.Errorf("第%d行用户ID为空", i+1)
		}
		if item.Price < 0 {
			return fmt.Errorf("第%d行订单金额不能为负数", i+1)
		}
	}

	return nil
}

// OrderData 订单数据结构
type OrderData struct {
	OrderSn     string    `json:"order_sn"`
	UserId      uint32    `json:"user_id"`
	DriverId    uint32    `json:"driver_id"`
	OrderType   int8      `json:"order_type"`
	Price       float64   `json:"price"`
	CreateAt    time.Time `json:"create_at"`
	OrderStatus int8      `json:"order_status"`
}

// createOrderSummarySheet 创建订单汇总工作表
func createOrderSummarySheet(exporter *ExcelExporter, data []OrderData) error {
	// 创建汇总工作表
	if err := exporter.CreateSheet("数据汇总"); err != nil {
		return err
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("数据汇总"); err != nil {
		return err
	}

	// 写入汇总表头
	summaryHeaders := []string{"统计项目", "数值", "说明"}
	if err := exporter.WriteHeaders("数据汇总", summaryHeaders); err != nil {
		return err
	}

	// 计算汇总数据
	totalAmount := 0.0
	totalRecords := len(data)
	orderTypeStats := make(map[int8]int)
	orderStatusStats := make(map[int8]int)

	for _, item := range data {
		totalAmount += item.Price
		orderTypeStats[item.OrderType]++
		orderStatusStats[item.OrderStatus]++
	}

	// 写入汇总数据
	summaryData := [][]interface{}{
		{"总记录数", totalRecords, "导出的订单记录总数"},
		{"总金额(元)", fmt.Sprintf("%.2f", totalAmount), "所有订单的总金额"},
		{"平均订单金额(元)", fmt.Sprintf("%.2f", totalAmount/float64(totalRecords)), "每个订单的平均金额"},
		{"导出时间", time.Now().Format("2006-01-02 15:04:05"), "数据导出的时间"},
	}

	// 添加订单类型统计
	for orderType, count := range orderTypeStats {
		summaryData = append(summaryData, []interface{}{
			fmt.Sprintf("%s订单数", getOrderTypeText(orderType)),
			count,
			fmt.Sprintf("%s类型订单的数量", getOrderTypeText(orderType)),
		})
	}

	// 添加订单状态统计
	for orderStatus, count := range orderStatusStats {
		summaryData = append(summaryData, []interface{}{
			fmt.Sprintf("%s订单数", getOrderStatusText(int32(orderStatus))),
			count,
			fmt.Sprintf("%s状态订单的数量", getOrderStatusText(int32(orderStatus))),
		})
	}

	if err := exporter.WriteRows("数据汇总", 2, summaryData); err != nil {
		return err
	}

	// 设置列宽
	exporter.SetColumnWidth("数据汇总", "A", 20)
	exporter.SetColumnWidth("数据汇总", "B", 20)
	exporter.SetColumnWidth("数据汇总", "C", 40)

	return nil
}

// 带重试的Excel创建
func CreateOrderExcelWithRetry(taskID string, data []OrderData, maxRetries int) (string, error) {
	var lastErr error
	
	for i := 0; i < maxRetries; i++ {
		filePath, err := CreateOrderExcelWithProgress(taskID, data, nil)
		if err == nil {
			return filePath, nil
		}
		
		lastErr = err
		log.Printf("第%d次创建Excel失败: %v", i+1, err)
		
		if i < maxRetries-1 {
			// 等待一段时间后重试
			time.Sleep(time.Duration(i+1) * time.Second)
		}
	}
	
	return "", fmt.Errorf("经过%d次重试后仍然失败: %v", maxRetries, lastErr)
}

// 流式处理大数据量
func CreateOrderExcelStream(taskID string, dataProvider func() ([]OrderData, error), progressCallback func(int, int)) (string, error) {
	// 创建Excel导出器
	exporter, err := NewExcelExporter("order_export_" + taskID)
	if err != nil {
		return "", fmt.Errorf("创建Excel导出器失败: %v", err)
	}
	defer exporter.Close()

	// 创建主工作表
	if err := exporter.CreateSheet("订单数据"); err != nil {
		return "", fmt.Errorf("创建工作表失败: %v", err)
	}

	// 设置活动工作表
	if err := exporter.SetActiveSheet("订单数据"); err != nil {
		return "", fmt.Errorf("设置活动工作表失败: %v", err)
	}

	// 写入表头
	headers := []string{
		"订单编号", "用户ID", "司机ID", "订单类型", "订单金额(元)", "创建时间", "订单状态",
	}

	if err := exporter.WriteHeaders("订单数据", headers); err != nil {
		return "", fmt.Errorf("写入表头失败: %v", err)
	}

	// 流式处理数据
	rowIndex := 2
	totalProcessed := 0
	
	for {
		batch, err := dataProvider()
		if err != nil {
			return "", fmt.Errorf("获取数据失败: %v", err)
		}
		
		if len(batch) == 0 {
			break // 没有更多数据
		}
		
		// 批量写入数据
		var batchData [][]interface{}
		for _, item := range batch {
			rowData := []interface{}{
				item.OrderSn,
				item.UserId,
				item.DriverId,
				getOrderTypeText(item.OrderType),
				item.Price,
				item.CreateAt.Format("2006-01-02 15:04:05"),
				getOrderStatusText(int32(item.OrderStatus)),
			}
			batchData = append(batchData, rowData)
		}
		
		if err := exporter.WriteRows("订单数据", rowIndex, batchData); err != nil {
			return "", fmt.Errorf("写入数据行失败: %v", err)
		}
		
		rowIndex += len(batch)
		totalProcessed += len(batch)
		
		// 调用进度回调
		if progressCallback != nil {
			progressCallback(totalProcessed, -1) // -1表示总数未知
		}
	}

	// 设置列宽
	columnWidths := map[string]float64{
		"A": 20, "B": 10, "C": 10, "D": 12, "E": 15, "F": 20, "G": 12,
	}

	for col, width := range columnWidths {
		if err := exporter.SetColumnWidth("订单数据", col, width); err != nil {
			log.Printf("设置列宽失败: %v", err)
		}
	}

	// 保存文件
	if err := exporter.Save(); err != nil {
		return "", fmt.Errorf("保存Excel文件失败: %v", err)
	}

	log.Printf("订单Excel文件创建成功: %s", exporter.GetFilePath())
	return exporter.GetFilePath(), nil
}

// 获取订单类型文本
func getOrderTypeText(orderType int8) string {
	switch orderType {
	case 1:
		return "实时单"
	case 2:
		return "预约单"
	case 3:
		return "接机单"
	case 4:
		return "送机单"
	default:
		return "未知"
	}
}
